#include<iostream>
#include<typeinfo>

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder(){}
        virtual const std::type_info& type() = 0;
        virtual holder* clone() = 0;
    };

    template<class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T& val) :_val(val){}

        virtual const std::type_info& type() //获取子类对象保存的数据类型
        {
            return typeid(T);
        }

        virtual holder* clone() //针对当前对象自身，克隆出新的子类对象
        {
            return new placeholder(_val);
        }
    public:
        T _val;
    };

    holder* _content;
public:
    Any():_content(nullptr){}

    template<class T>
    Any(const T& val):_content(new placeholder<T>(val)){}

    Any(const Any& other):_content(other._content ? other._content->clone() : nullptr){}

    ~Any()
    {
        delete _content;   
    }

    Any& swap(Any& other)
    {
        std::swap(_content, other._content);
        return *this;
    }

    template<class T>
    T* get() //返回子类保存的数据的指针
    {
        //想要获取的数据类型，必须和保存的数据类型一致
        if(typeid(T) != _content->type())
            return nullptr;

        return &((placeholder<T>*)_content)->_val;
    }

    template<class T>
    Any& operator=(const T& val)
    {
        //为val构造一个临时对象，然后和当前容器交换内部的成员
        Any(val).swap(*this);
        return *this;
    }

    Any& operator=(const Any& other)
    {
        Any(other).swap(*this);
        return *this;
    }
};

class Test
{
public:
    Test(){std::cout << "构造" << std::endl;}
    Test(const Test& t){std::cout << "拷贝" << std::endl;}
    ~Test(){std::cout << "析构" << std::endl;}
};

int main()
{
    {
        Any a;
        Test t;
        a = t;
    }

    // a = 10;
    // int *pa = a.get<int>();
    // std::cout << *pa << std::endl;
    // a = std::string("nihao");
    // std::string* ps = a.get<std::string>();
    // std::cout << *ps << std::endl;
    
    return 0;
}

